home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1996 June / EnigmA AMIGA RUN 08 (1996)(G.R. Edizioni)(IT)[!][issue 1996-06][EARSAN CD VII].iso / earcd / utilsys / rss14gmd.lha / RSys_1.4gmd / C / Utils.c < prev   
C/C++ Source or Header  |  1996-05-04  |  24KB  |  1,199 lines
  1. /*
  2.    ***************************************************************************
  3.    *
  4.    * Datei:
  5.    *      RSysUtils.c
  6.    *
  7.    * Inhalt:
  8.    *
  9.    *      --- Globale Routinen ---
  10.    *
  11.    *    char *B2CStr ( char *ret , BSTR inp );
  12.    *    char *strcpy ( char *dest , const char *src );
  13.    *    char *strncpy ( char *dest , const char *src , size_t len );
  14.    *    int exist ( char *name );
  15.    *    int Question ( WINDOW *wind , char *ask , int def );
  16.    *    int SizeOfDir ( BPTR lock , long *Size , int *Dirs );
  17.    *    long ahtoi ( char *String );
  18.    *    LONG Command ( NODE *node , char *file );
  19.    *    long getdisktype ( BPTR lock );
  20.    *    long SizeOfFile ( char *Name );
  21.    *    ScrollEntry *AllocScrollEntries ( int count );
  22.    *    DISKOBJECT *GetProgramIcon ( void );
  23.    *    NODE *GetNode ( LIST *list , ULONG offset );
  24.    *    void *MyAllocVec ( unsigned long byteSize , unsigned long requirements , int kill );
  25.    *    void AddNodeSorted ( LIST *list , NODE *node , int sortpos );
  26.    *    void AddNodeToList ( int i , int sort_in , int sortpos );
  27.    *    void CloseAll ( void );
  28.    *    void CloseLibs ( void );
  29.    *    void CreateEntryList ( int sorting, int sortpos );
  30.    *    void FreeBytes ( char *Vol , long *free , long *used , long *usedpercent , char *state , char *type );
  31.    *    void MyFreeVec ( void *memptr );
  32.    *    void OpenLibs ( void );
  33.    *    void quit ( int askyou );
  34.    *    void savestrcpy ( char *str , NODE *node , int cnt , int type );
  35.    *    void ToggleAskingMode ( void );
  36.    *    void ToggleAutoFront ( void );
  37.    *    void ToggleFastMode ( void );
  38.    *    void ToggleMouseWindow ( void );
  39.    *    void ToggleSortMode ( void );
  40.    *    void ToggleSpeakMode ( void );
  41.    *    void ToggleTextFormatter ( void );
  42.    *    void ToggleTopazFont ( void );
  43.    *    void ToggleWorkingBar ( void );
  44.    *
  45.    *      --- Lokale  Routinen ---
  46.    *
  47.    *    static int StrICmp ( const char *s1 , char *s2 );
  48.    *    static UWORD InitBar ( void );
  49.    *    static void RefreshBar ( int curr );
  50.    *    static void RemoveBar ( UWORD pos );
  51.    *
  52.    * Bemerkungen:
  53.    *      Utilities, die im ganzen Programm verwendet werden, z.B.
  54.    *      Listen- und Stringverwaltungsroutinen.
  55.    *
  56.    * Erstellungsdatum:
  57.    *      07-Jan-93     Rolf Böhme
  58.    *
  59.    * Änderungen:
  60.    *      07-Jan-93     Rolf Böhme        Erstellung
  61.    *
  62.    ***************************************************************************
  63.  */
  64.  
  65. #include "RSys.h"
  66. #include "protos.h"
  67.  
  68.  /*
  69.   * strncpy() ersetzt die Compiler-Routine. Im Gegensatz zur
  70.   * Orginalroutine wird der Zielstring korrekt terminiert
  71.   */
  72. char *
  73. strncpy (char *dest, const char *src, size_t len)
  74. {
  75.   size_t i = len;
  76.   char *tmp = dest;
  77.  
  78.   if (src)
  79.     while ((*(tmp++) = *(src++)) && --i);
  80.  
  81.   *tmp = STRINGEND;
  82.  
  83.   return dest;
  84. }
  85.  
  86.  /*
  87.   * strcpy() ersetzt die Compiler-Routine. Im Gegensatz zur
  88.   * Orginalroutine wird überprüft, ob der Quellstring
  89.   * überhaupt existiert und kein NULL-Zeiger übergeben
  90.   * wurde
  91.   */
  92. char *
  93. strcpy (char *dest, const char *src)
  94. {
  95.   char *tmp = dest;
  96.  
  97.   if (src)
  98.     while (*(tmp++) = *(src++));
  99.   else
  100.     *tmp = STRINGEND;
  101.  
  102.   return dest;
  103. }
  104.  
  105. long
  106. ahtoi (char *String)
  107. {
  108.   long Value = 0;
  109.   char c;
  110.  
  111.   while (c = *String)
  112.     {
  113.       Value = Value << 4;
  114.  
  115.       if (c >= '0' && c <= '9')
  116.     Value |= (c & 15);
  117.       else
  118.     Value |= (c & 15) + 9;
  119.  
  120.       ++String;
  121.     }
  122.  
  123.   return Value;
  124. }
  125.  
  126.  /*
  127.   * MyAllocVec() ist eine Erweiterung der AllocVec()-Routine. In
  128.   * einem Fehlerfall wird eine Meldung ausgegeben und das
  129.   * Programm evtl korrekt beendet
  130.   */
  131. void *
  132. MyAllocVec (unsigned long byteSize, unsigned long requirements, int kill)
  133. {
  134.   void *memptr = NULL;
  135.  
  136.   DPOS;
  137.  
  138.   if (NOT (memptr = AllocVec (byteSize, requirements)))
  139.     ErrorHandle (__FUNC__ "()", MEMORY_ERR, ALLOC_FAIL, kill);
  140.  
  141.   return memptr;
  142. }
  143.  
  144.  /*
  145.   * MyFreeVec() prüft im Gegensatz zu Originalroutine, ob ein
  146.   * NULL-Zeiger übergeben wurde
  147.   */
  148. void
  149. MyFreeVec (void *memptr)
  150. {
  151.   DPOS;
  152.  
  153.   if (memptr != NULL)
  154.     FreeVec (memptr);
  155.   memptr = NULL;
  156.  
  157.   return;
  158. }
  159.  
  160.  
  161.  /*
  162.   * Command() führt einen Befehl in einem eigenen Prozeß aus.
  163.   * Als Aus- und Eingabekanal wird das Window verwendet, das im
  164.   * RSys-Icon festgelegt wurde
  165.   */
  166. LONG
  167. Command (NODE * node, char *file)
  168. {
  169.   TAGITEM stags[5];
  170.   LONG result = -2;
  171.   BPTR fileptr;
  172.   RSYS_acts *Act = (RSYS_acts *) node;
  173.   UBYTE cmd[512];
  174.  
  175.   DPOS;
  176.  
  177.   if (node && strcmp (Act->act_command, field[NO_FIELD]) &&
  178.       (fileptr = Open (autocon, MODE_OLDFILE)))
  179.     {
  180.       stags[0].ti_Tag = SYS_Input;
  181.       stags[0].ti_Data = fileptr;
  182.       stags[1].ti_Tag = SYS_Output;
  183.       stags[1].ti_Data = NULL;
  184.       stags[2].ti_Tag = SYS_Asynch;
  185.       stags[2].ti_Data = FALSE;
  186.       stags[3].ti_Tag = SYS_UserShell;
  187.       stags[3].ti_Data = TRUE;
  188.       stags[4].ti_Tag = TAG_DONE;
  189.  
  190.       sprintf ((char *) cmd, "%s \"%s\"", Act->act_command, file);
  191.  
  192.       result = System (cmd, stags);
  193.       if (result == -1L)
  194.     {
  195.       Close (fileptr);
  196.       ErrorHandle ((char *) cmd, TASK_ERR, CREATE_FAIL, NO_KILL);
  197.     }
  198.     }
  199.  
  200.   return result;
  201. }
  202.  
  203.  /*
  204.   * GetProgramIcon() ermittelt das aktuelle Icon von RSys
  205.   */
  206.  
  207. DISKOBJECT *
  208. GetProgramIcon (void)
  209. {
  210.   DISKOBJECT *Icon = NULL;
  211.  
  212.   DPOS;
  213.  
  214.   if (Icon = GetDiskObjectNew ((STRPTR) RSysName))
  215.     {
  216.       if (Icon->do_Type != WBTOOL)
  217.     {
  218.       FreeDiskObject (Icon);
  219.       Icon = NULL;
  220.     }
  221.     }
  222.  
  223.   if (!Icon)
  224.     {
  225.       BPTR NewLock;
  226.  
  227.       /* Move to the directory the
  228.        * program was run from.
  229.        */
  230.  
  231.       if (NewLock = Lock ((STRPTR) "PROGDIR:", ACCESS_READ))
  232.     {
  233.       BPTR OldLock;
  234.  
  235.       OldLock = CurrentDir (NewLock);
  236.  
  237.       /* Try to fetch the icon, use the
  238.        * default name if necessary.
  239.        */
  240.  
  241.       if (Icon = GetDiskObjectNew ((STRPTR) "RSys"))
  242.         {
  243.           if (Icon->do_Type != WBTOOL)
  244.         {
  245.           FreeDiskObject (Icon);
  246.  
  247.           Icon = NULL;
  248.         }
  249.         }
  250.  
  251.       CurrentDir (OldLock);
  252.  
  253.       UnLock (NewLock);
  254.     }
  255.     }
  256.  
  257.   if (!Icon)
  258.     {
  259.       /* Use the default names. */
  260.  
  261.       Icon = GetDefDiskObject (WBTOOL);
  262.       if (!Icon)
  263.     ErrorHandle ("DefaultIcon", ICON_ERR, ALLOC_FAIL, NO_KILL);
  264.     }
  265.  
  266.   return Icon;
  267. }
  268.  
  269.  /*
  270.   * ToggleFastMode() schaltet zwischen der schnellen Anzeige (die
  271.   * Listenelemente werden während der Erzeugung nicht angezeigt)
  272.   * und der langsamen Anzeige (wenn ein Eintrag erzeugt wurde,
  273.   * wird er sofort angezeigt)
  274.   */
  275. void
  276. ToggleFastMode (void)
  277. {
  278.   DPOS;
  279.  
  280.   HandleHelp (MN_ToggleFastMode);
  281.  
  282.   Flags.fastmode = ~Flags.fastmode;
  283.  
  284.   PrintInfo (Flags.fastmode ? "Fast mode on" : "Fast mode off", SPEAK, SEC);
  285.  
  286.   PrintStatistics ();
  287.  
  288.   return;
  289. }
  290.  
  291.  /*
  292.   * ToggleAskingMode() schaltet die Sicherheits-
  293.   * abfrage bei kritischen Aktionen ein oder aus
  294.   */
  295. void
  296. ToggleAskingMode (void)
  297. {
  298.   DPOS;
  299.  
  300.   HandleHelp (MN_ToggleAskingMode);
  301.  
  302.   Flags.saveasking = ~Flags.saveasking;
  303.  
  304.   PrintInfo (Flags.saveasking ? "Save asking mode on" : "Save asking mode off", SPEAK, SEC);
  305.  
  306.   PrintStatistics ();
  307.  
  308.   return;
  309. }
  310.  
  311. void
  312. ToggleTextFormatter (void)
  313. {
  314.   DPOS;
  315.  
  316.   HandleHelp (MN_TextFormatter);
  317.  
  318.   Flags.textformat = ~Flags.textformat;
  319.  
  320.   PrintInfo (Flags.textformat ? "Text formatting on" : "Text formatting off", SPEAK, SEC);
  321.  
  322.   PrintStatistics ();
  323.  
  324.   return;
  325. }
  326.  
  327.  /*
  328.   * ToggleSortMode() schaltet zwischen dem sortierten und
  329.   * direkten Einfügen von Listenelementen um
  330.   */
  331. void
  332. ToggleSortMode (void)
  333. {
  334.   DPOS;
  335.  
  336.   HandleHelp (MN_ToggleSortMode);
  337.  
  338.   Flags.sortmode = ~Flags.sortmode;
  339.  
  340.   PrintInfo (Flags.sortmode ? "List sorting on" : "List sorting off", SPEAK, SEC);
  341.  
  342.   RefreshList (LastID);
  343.  
  344.   PrintStatistics ();
  345.  
  346.   return;
  347. }
  348.  
  349.  /*
  350.   * ToggleWorkingBar() schaltet die Anzeige des Working Bars
  351.   * (Anzeigestatus in Form eines Laufbalkens) um
  352.   */
  353. void
  354. ToggleWorkingBar (void)
  355. {
  356.   DPOS;
  357.  
  358.   HandleHelp (MN_ToggleWorkingBar);
  359.  
  360.   Flags.workingbar = ~Flags.workingbar;
  361.  
  362.   PrintInfo (Flags.workingbar ? "Working bar on" : "Working bar off", SPEAK, SEC);
  363.  
  364.   RefreshList (LastID);
  365.  
  366.   PrintStatistics ();
  367.  
  368.   return;
  369. }
  370.  
  371.  /*
  372.   * ToggleSpeakMode() schaltet die Sprachausgabe ein oder aus.
  373.   * Alle Mitteilungen, die im Textgadget unten im Hauptwindow
  374.   * erscheinen, werden über das narrator.device ausgegeben, wenn
  375.   * der Modus eingeschaltet wurde
  376.   */
  377. void
  378. ToggleSpeakMode (void)
  379. {
  380.   DPOS;
  381.  
  382.   HandleHelp (MN_ToggleSpeakMode);
  383.  
  384.   Flags.speakmode = ~Flags.speakmode;
  385.  
  386.   if (NOT (Flags.speakmode))
  387.     RemoveSpeech ();
  388.   else if (NOT (InitSpeech ()))
  389.     Flags.speakmode = ~Flags.speakmode;
  390.  
  391.   PrintInfo (Flags.speakmode ? "Speak mode on" : "Speak mode off", SPEAK, SEC);
  392.  
  393.   PrintStatistics ();
  394.  
  395.   return;
  396. }
  397.  
  398.  /*
  399.   * ToggleAutoFront() ermöglicht das Öffnen eines Fensters
  400.   * mit anschließendem Nach-Vorne-Bringen dieses Fensters
  401.   */
  402. void
  403. ToggleAutoFront (void)
  404. {
  405.   DPOS;
  406.  
  407.   HandleHelp (MN_ToggleAutoFront);
  408.  
  409.   Flags.autofront = ~Flags.autofront;
  410.  
  411.   PrintInfo (Flags.autofront ? "Auto front on" : "Auto front off", SPEAK, SEC);
  412.  
  413.   PrintStatistics ();
  414.  
  415.   return;
  416. }
  417.  
  418.  /*
  419.   * ToggleMouseWindow() schaltet die Möglichkeit ein oder aus,
  420.   * alle Fenster von RSys unter dem Mauszeiger zu öffnen
  421.   */
  422. void
  423. ToggleMouseWindow (void)
  424. {
  425.   DPOS;
  426.  
  427.   HandleHelp (MN_ToggleMouseWindow);
  428.  
  429.   Flags.mousewindow = ~Flags.mousewindow;
  430.  
  431.   PrintInfo (Flags.mousewindow ? "Mouse window on" : "Mouse window off", SPEAK, SEC);
  432.  
  433.   PrintStatistics ();
  434.  
  435.   return;
  436. }
  437.  
  438.  /*
  439.   * ToggleTopazFont() schaltet zwischen der Verwendung des
  440.   * System-Fonts und dem Topaz-Font um. Wird als
  441.   * System-Workbench-Font ein proportionaler Zeichensatz
  442.   * gewählt, sehen die Listen etwas unformatiert aus. Topaz ist
  443.   * ein unproportionaler Font, der Listen korrekt formatiert
  444.   * darstellt
  445.   */
  446. void
  447. ToggleTopazFont (void)
  448. {
  449.  
  450.   DPOS;
  451.  
  452.   HandleHelp (MN_ToggleTopazFont);
  453.  
  454.   Flags.sysfont = ~Flags.sysfont;
  455.  
  456.   CloseASysWindow (&SysWnd, &SysGList, &SysMenus);
  457.   CloseDownScreen ();
  458.  
  459.   OpenMainWindow ();
  460.  
  461.   RefreshList (LastID);
  462.  
  463.   PrintInfo (Flags.sysfont ? "Topaz font on" : "Topaz font off", SPEAK, SEC);
  464.  
  465.   PrintStatistics ();
  466.  
  467.   ReopenWindow = TRUE;
  468.  
  469.   return;
  470. }
  471.  
  472.  /*
  473.   * StrICmp() ersetzt die Utility-Library- und Aztec-C-Routine.
  474.   * Beide liefern enforcer-Hits, falls man sie mit Leer- oder
  475.   * NULL-Strings aufruft
  476.   */
  477. static int
  478. StrICmp (const char *s1, char *s2)
  479. {
  480.   int c1, c2, diff = 0;
  481.  
  482.   while (s1 && *s1 && s2 && *s2 && (diff == 0))
  483.     {
  484.       c1 = toupper ((int) (*s1));
  485.       c2 = toupper ((int) (*s2));
  486.       diff = c1 - c2;
  487.  
  488.       s1++;
  489.       s2++;
  490.     }
  491.  
  492.   return diff;
  493. }
  494.  
  495. #define STRICMP(src,dest) StrICmp((char *)(src),(char *)(dest))
  496.  
  497.  /*
  498.   * AddNodeSorted() sortiert ein Listenelement in eine
  499.   * bestehende Liste ein. Da die hier betrachteten Listen
  500.   * ziemlich klein sind, wird hier ein einfaches Sortieren durch
  501.   * Einfügen verwendet. Das Sortieren erfolg ab einer bestimmten
  502.   * Position sortpos.
  503.   */
  504. void
  505. AddNodeSorted (LIST * list, NODE * node, int sortpos)
  506. {
  507.   NODE *head = list->lh_Head, *loop_node;
  508.   BOOL ins = FALSE;
  509.  
  510.   if (IsListEmpty (list))
  511.     AddHead (list, node);
  512.   else if (head->ln_Succ == NULL)
  513.     {
  514.       if (STRICMP (&head->ln_Name[sortpos], &node->ln_Name[sortpos]) <= 0L)
  515.     AddTail (list, node);
  516.       else
  517.     AddHead (list, node);
  518.  
  519.       ins = TRUE;
  520.     }
  521.   else
  522.     {
  523.       if (STRICMP (&head->ln_Name[sortpos], &node->ln_Name[sortpos]) > 0L)
  524.     {
  525.       AddHead (list, node);
  526.       ins = TRUE;
  527.     }
  528.  
  529.       for (loop_node = head;
  530.     loop_node->ln_Succ && loop_node->ln_Succ->ln_Succ && (ins == FALSE);
  531.        loop_node = loop_node->ln_Succ)
  532.     {
  533.       if ((STRICMP (&loop_node->ln_Name[sortpos], &node->ln_Name[sortpos]) <= 0L) &&
  534.           (STRICMP (&node->ln_Name[sortpos], &loop_node->ln_Succ->ln_Name[sortpos]) < 0L))
  535.         {
  536.           Insert (list, node, loop_node);
  537.           ins = TRUE;
  538.         }
  539.     }
  540.  
  541.       if (ins == FALSE)
  542.     AddTail (list, node);
  543.     }
  544.  
  545.   return;
  546. }
  547.  
  548. static ULONG xmin, ymin, xmax, ymax;
  549.  
  550.  /*
  551.   * InitBar() entfernt das Informationen-Text-Gadget; dabei
  552.   * bleibt der Rahmen stehen (dank Intuition). Dieser Rahmen
  553.   * wird dann als Begrenzung für den Statusbalken verwendet.
  554.   * Der Balkenbereich wird dann gelöscht und die Zeichenmodi
  555.   * eingestellt.
  556.   */
  557. static UWORD
  558. InitBar (void)
  559. {
  560.   UWORD pos = RemoveGadget (SysWnd, SysGadgets[18]);
  561.   RASTPORT *RP;
  562.  
  563.   RP = SysWnd->RPort;
  564.  
  565.   xmin = SysGadgets[18]->LeftEdge + 1;
  566.   ymin = SysGadgets[18]->TopEdge + 1;
  567.  
  568.   xmax = SysGadgets[18]->LeftEdge + SysGadgets[18]->Width - 4;
  569.   ymax = SysGadgets[18]->TopEdge + SysGadgets[18]->Height - 2;
  570.  
  571.   EraseRect (RP, xmin, ymin, xmax, ymax);
  572.  
  573.   SetDrMd (RP, JAM1);
  574.   SetAPen (RP, 3);
  575.   SetBPen (RP, 0);
  576.  
  577.   return (pos);
  578. }
  579.  
  580.  /*
  581.   * RefreshBar() aktualisiert die Anzeige des Statusbalkens.
  582.   * Dazu wird wie folgt vorgegangen:
  583.   * 1. Neue Breite des Balkens und Prozentzahl berechnen
  584.   * 2. Den Bereich mit Farbe füllen
  585.   * 3. Falls es nicht der letzte Eintrag war, wird
  586.   *     der Rest des Balkenbereichs (rechts) gelöscht
  587.   */
  588. static void
  589. RefreshBar (int curr)
  590. {
  591.   ULONG xcurr = xmin + ((xmax - xmin) * curr) / countentries;
  592.  
  593.   RectFill (SysWnd->RPort, xmin, ymin, xcurr, ymax);
  594.  
  595.   return;
  596. }
  597.  
  598.  /*
  599.   * RemoveBar() löscht den Bereich des für den Statusbalkens
  600.   * entfernten Gadgets und hängt das Gadget wieder ein
  601.   */
  602. static void
  603. RemoveBar (UWORD pos)
  604. {
  605.   SetAPen (SysWnd->RPort, 0);
  606.  
  607.   EraseRect (SysWnd->RPort, xmin, ymin, xmax, ymax);
  608.  
  609.   AddGadget (SysWnd, SysGadgets[18], (ULONG) pos);
  610.  
  611.   RefreshGList (SysGadgets[18], SysWnd, NULL, 1);
  612.   GT_RefreshWindow (SysWnd, NULL);
  613.  
  614.   return;
  615. }
  616.  
  617.  /*
  618.   * AddNodeToList() ist eine Schnittstelle zwischen den Routinen
  619.   * AddNodeSorted() und AddTail(). Je nachdem, ob ein Element in
  620.   * die Liste sortiert einfügt werden soll oder nicht, werden
  621.   * die entsprechenden Routinen aufgerufen
  622.   */
  623. void
  624. AddNodeToList (int i, int sort_in, int sortpos)
  625. {
  626.   LIST *list = &ListeLVList;
  627.   NODE *head = list->lh_Head, *node = &(Entries[i].se_Node);
  628.   UWORD gadpos;
  629.  
  630.   if (Flags.workingbar && (i == 0))
  631.     gadpos = InitBar ();
  632.  
  633.   if (Flags.sortmode && sort_in && head && node->ln_Name)
  634.     AddNodeSorted (list, node, sortpos);
  635.   else
  636.     AddTail (list, node);
  637.  
  638.   if (NOT (Flags.fastmode))
  639.     {
  640.       RefreshListView ();
  641.       WaitTOF ();
  642.     }
  643.  
  644.   if (Flags.workingbar)
  645.     {
  646.       RefreshBar (i);
  647.  
  648.       if (i == (countentries - 1))
  649.     {
  650.       RefreshBar (countentries);
  651.       RemoveBar (gadpos);
  652.     }
  653.     }
  654.  
  655.   return;
  656. }
  657.  
  658.  /*
  659.   * CreateEntryList() fügt die Entries in die Anzeigeliste ein.
  660.   */
  661. void
  662. CreateEntryList (int sorting, int sortpos)
  663. {
  664.   int i;
  665.  
  666.   for (i = 0; i < countentries; i++)
  667.     AddNodeToList (i, sorting, sortpos);
  668.  
  669.   return;
  670. }
  671.  
  672.  /*
  673.   * B2CStr() wandelt einen BCPL-String in einen C-String um
  674.   */
  675. char *
  676. B2CStr (char *dest, BSTR inp)
  677. {
  678.   int i;
  679.   char *help = (char *) BADDR (inp);
  680.  
  681.   DPOS;
  682.  
  683.   for (i = 0; i < *help; i++)
  684.     *(dest + i) = *(help + i + 1);
  685.  
  686.   *(dest + i) = STRINGEND;
  687.  
  688.   return dest;
  689. }
  690.  
  691.  /*
  692.   * savestrcpy() kopiert eine Anzahl von Zeichen eines
  693.   * Node-Namens in einen Zielstring. Hierbei wird darauf
  694.   * geachtet, daß ein Node-Name überhaupt existiert
  695.   */
  696. void
  697. savestrcpy (char *str, NODE * node, int cnt, int type)
  698. {
  699.  
  700.   DPOS;
  701.  
  702.   if (!node || !(node->ln_Name))
  703.     {
  704.       strcpy (str, field[NO_NODE]);
  705.       return;
  706.     }
  707.  
  708.   if ((type == NT_TASK) && (node->ln_Type == NT_PROCESS))
  709.     type = NT_PROCESS;
  710.   if ((type == NT_SEMAPHORE) && (node->ln_Type == NT_SIGNALSEM))
  711.     type = NT_SIGNALSEM;
  712.  
  713.  
  714.   if (node->ln_Type == type)
  715.     strncpy (str, node->ln_Name, cnt);
  716.   else
  717.     sprintf (str, field[WRONG_TYPE_FMT], node->ln_Type);
  718.  
  719.  
  720.   return;
  721. }
  722.  
  723.  /*
  724.   * GetNode() ermittelt einen Eintrag, dessen Abstand vom
  725.   * Listenkopf in offset angegeben wird, also das offset'te
  726.   * Element
  727.   */
  728. NODE *
  729. GetNode (LIST * list, ULONG offset)
  730. {
  731.   NODE *Node;
  732.   LONG i;
  733.  
  734.   DPOS;
  735.  
  736.   Node = (NODE *) list->lh_Head;
  737.  
  738.   for (i = 0; i < offset; i++)
  739.     {
  740.       if (!Node->ln_Succ)
  741.     return NULL;
  742.  
  743.       Node = Node->ln_Succ;
  744.     }
  745.  
  746.   return Node;
  747. }
  748.  
  749.  /*
  750.   * SizeOfFile() ermittelt die Größe einer Datei
  751.   */
  752. long
  753. SizeOfFile (char *Name)
  754. {
  755.   FILEINFOBLOCK *FileInfo;
  756.   LONG FileSize = 0L;
  757.  
  758.   DPOS;
  759.  
  760.   if (NOT (exist (Name)))
  761.     return FileSize;
  762.  
  763.   if (FileInfo = (FILEINFOBLOCK *) AllocDosObject (DOS_FIB, TAG_DONE))
  764.     {
  765.       BPTR FileLock;
  766.  
  767.       if (FileLock = Lock ((UBYTE *) Name, ACCESS_READ))
  768.     {
  769.       if (Examine (FileLock, FileInfo))
  770.         FileSize = FileInfo->fib_Size;
  771.  
  772.       UnLock (FileLock);
  773.     }
  774.  
  775.       FreeDosObject (DOS_FIB, FileInfo);
  776.     }
  777.  
  778.   return FileSize;
  779. }
  780.  
  781.  /*
  782.   * SizeOfDir() ermittelt die Größe eines Directories, also die
  783.   * Größe aller in ihr enthaltenen Dateien
  784.   */
  785. int
  786. SizeOfDir (BPTR lock, long *Size, int *Dirs)
  787. {
  788.   EXALLCONTROL *eac;
  789.   EXALLDATA *EAData, *ead;
  790.   int cnt = 0, more;
  791.  
  792.   DPOS;
  793.  
  794.   if (eac = AllocDosObject (DOS_EXALLCONTROL, NULL))
  795.     {
  796.       eac->eac_LastKey = 0;
  797.  
  798.       EAData = MyAllocVec (513 * sizeof (EXALLDATA),
  799.                MEMF_ANY | MEMF_CLEAR, NO_KILL);
  800.  
  801.       if (EAData)
  802.     {
  803.       do
  804.         {
  805.           more = ExAll (lock, EAData, 512 * sizeof (EXALLDATA), ED_SIZE, eac);
  806.  
  807.           if ((!more) && (IoErr () != ERROR_NO_MORE_ENTRIES))
  808.         {
  809.           ErrorHandle ("On a lock", DOS_EXALL_ERR, EXALL_FAIL, NO_KILL);
  810.           break;
  811.         }
  812.  
  813.           if (eac->eac_Entries == 0)
  814.         continue;
  815.  
  816.           ead = EAData;
  817.  
  818.           do
  819.         {
  820.           if (SetSignal (0L, SIGBREAKF_CTRL_C) & SIGBREAKF_CTRL_C)
  821.             {
  822.               more = FALSE;
  823.               break;
  824.             }
  825.  
  826.           *Size += ead->ed_Size;
  827.  
  828.           if (ead->ed_Type > 0)
  829.             (*Dirs)++;
  830.           else
  831.             cnt++;
  832.  
  833.           ead = ead->ed_Next;
  834.  
  835.         }
  836.           while (ead);
  837.         }
  838.       while (more);
  839.     }
  840.  
  841.       MyFreeVec (EAData);
  842.  
  843.       FreeDosObject (DOS_EXALLCONTROL, eac);
  844.     }
  845.   else
  846.     ErrorHandle ("AllocDosObject()", MEMORY_ERR, ALLOC_FAIL, KILL);
  847.  
  848.   return cnt;
  849. }
  850.  
  851.  /*
  852.   * AllocScrollEntries() reserviert Speicher für die
  853.   * Listeneinträge des Haupt-ListViews. Werden weniger Einträge
  854.   * angefordert, als zuvor alloziert sind, wird kein neuer
  855.   * Speicher angefordert, sondern ein Zeiger auf die
  856.   * Ursprungs-Liste zurückgegeben, damit die Daten dann
  857.   * überschrieben werden können
  858.   */
  859. RSYS_ScrollEntry *
  860. AllocScrollEntries (int count)
  861. {
  862.   int i;
  863.   static int memcounter = 0;
  864.  
  865.   DPOS;
  866.  
  867.   if (count > memcounter)
  868.     {
  869.       if (Entries != NULL)
  870.     {
  871.       MyFreeVec (Entries);
  872.       Entries = NULL;
  873.     }
  874.  
  875.       if (Entries = (RSYS_ScrollEntry *) MyAllocVec (count * sizeof (RSYS_ScrollEntry),
  876.                            MEMF_ANY | MEMF_CLEAR, KILL))
  877.     {
  878.       for (i = 0; i < count; i++)
  879.         Entries[i].se_Node.ln_Name = Entries[i].se_Entry;
  880.  
  881.       memcounter = count;
  882.       maxentries = memcounter;
  883.  
  884.       return Entries;
  885.     }
  886.     }
  887.   else
  888.     return Entries;
  889.  
  890.   return NULL;
  891. }
  892.  
  893.  /*
  894.   * getdisktype() holt aus einem FileLock die Typ-Nummer des
  895.   * angemeldeten Devices heraus
  896.   */
  897. long
  898. getdisktype (BPTR lock)
  899. {
  900.   FILELOCK *fl = (FILELOCK *) BADDR (lock);
  901.  
  902.   return (((DEVICELIST *) BADDR (fl->fl_Volume))->dl_DiskType);
  903. }
  904.  
  905.  /*
  906.   * FreeBytes() ermittelt die Daten eines Volumes
  907.   */
  908. void
  909. FreeBytes (char *Vol, long *free, long *used, long *usedpercent,
  910.        char *state, char *type)
  911. {
  912.   BPTR lock = NULL;
  913.   int i;
  914.   INFODATA *ID = NULL;
  915.   union
  916.     {
  917.       LONG dostype;
  918.       char dostypestr[5];
  919.     }
  920.   convert;
  921.  
  922.   DPOS;
  923.  
  924.   if (ID = (INFODATA *) MyAllocVec (sizeof (INFODATA), MEMF_CLEAR, NO_KILL))
  925.     {
  926.       if (lock = Lock ((UBYTE *) Vol, ACCESS_READ))
  927.     {
  928.       if (Info (lock, ID))
  929.         {
  930.           *free = (((ID->id_NumBlocks - ID->id_NumBlocksUsed) *
  931.             ID->id_BytesPerBlock) >> 10);
  932.           *used = ((ID->id_NumBlocksUsed * ID->id_BytesPerBlock) >> 10);
  933.           *usedpercent = (100 * ID->id_NumBlocksUsed) / ID->id_NumBlocks;
  934.  
  935.           if ((convert.dostype = getdisktype (lock)) == 0L)
  936.         convert.dostype = ID->id_DiskType;
  937.  
  938.           if (convert.dostype != (long) (-1))
  939.         {
  940.           strncpy (type, convert.dostypestr, 4);
  941.           for (i = 0; i < 4; i++)
  942.             {
  943.               type[i] += ((int) type[i] < 10 ? 0x30 : 0x20);
  944.               type[i] = ToUpper ((int) type[i]);
  945.             }
  946.         }
  947.           else
  948.         strcpy (type, "NODI");
  949.  
  950.           if (strstr (Vol, "AX") || strstr (Vol, "AMAX"))
  951.         strcpy (type, "AMAX");
  952.  
  953.           switch (ID->id_DiskState)
  954.         {
  955.         case ID_WRITE_PROTECTED:
  956.           strcpy (state, "R/O");
  957.           break;
  958.  
  959.         case ID_VALIDATING:
  960.           strcpy (state, "VAL");
  961.           break;
  962.  
  963.         case ID_VALIDATED:
  964.           strcpy (state, "R/W");
  965.           break;
  966.  
  967.         default:
  968.           strcpy (state, field[NO_FIELD]);
  969.           break;
  970.         }
  971.         }
  972.       else
  973.         {
  974.           *free = 0L;
  975.           *used = 0L;
  976.           *usedpercent = 0;
  977.           strcpy (state, "NST");
  978.           strcpy (type, "NINF");
  979.         }
  980.  
  981.       UnLock (lock);
  982.     }
  983.       else
  984.     {
  985.       *free = 0L;
  986.       *used = 0L;
  987.       *usedpercent = 0;
  988.       strcpy (type, field[NO_FIELD]);
  989.       strcpy (state, "NOL");
  990.     }
  991.  
  992.       MyFreeVec (ID);
  993.     }
  994.  
  995.   return;
  996. }
  997.  
  998.  /*
  999.   * exist() prüft, ob ein File oder Directory angegebenen Namens
  1000.   * existiert
  1001.   */
  1002. int
  1003. exist (char *name)
  1004. {
  1005.   BPTR File;
  1006.  
  1007.   DPOS;
  1008.  
  1009.   if (NOT (name) || NOT (name[0]))
  1010.     return FALSE;
  1011.  
  1012.   if (File = Lock ((UBYTE *) name, ACCESS_READ))
  1013.     {
  1014.       UnLock (File);
  1015.       return TRUE;
  1016.     }
  1017.  
  1018.   return FALSE;
  1019. }
  1020.  
  1021.  /*
  1022.   * quit() beendet nach einer Sicherheitsabfrage das Programm
  1023.   */
  1024. void
  1025. quit (int askyou)
  1026. {
  1027.   WORD check = 1;
  1028. /*
  1029.    GMD
  1030.  
  1031.    UBYTE *answer = (UBYTE *) ((Flags.wb_start && !Flags.helpmode) ? "Yes|Iconify|No" : "Yes|No");
  1032.  */
  1033.  
  1034.   HandleHelp (MN_quit);
  1035.  
  1036.   DPOS;
  1037.  
  1038. /*
  1039.    if (Flags.saveasking && askyou)
  1040.    {
  1041.    check = MyEasyRequest (SysWnd, (UBYTE *) NAME " ask you",
  1042.    answer, (UBYTE *) "Quit program?");
  1043.    }
  1044.    GMD
  1045.  */
  1046.  
  1047.   check = 1;
  1048.  
  1049.   switch (check)
  1050.     {
  1051.     case 1:
  1052. /*
  1053.    GMD
  1054.    PrintInfo ("Bye bye", SPEAK, SEC);
  1055.  */
  1056.       CloseAll ();
  1057.       break;
  1058.  
  1059.     case 2:
  1060.       if (!appicon)
  1061.     Iconify ();
  1062.       break;
  1063.  
  1064.     default:
  1065.       break;
  1066.     }
  1067.  
  1068.   return;
  1069. }
  1070.  
  1071.  /*
  1072.   * Question() bietet eine Ja-Nein-Abfrage in Form eines
  1073.   * System-Requesters an. Ist das Flag saveasking ausgeschaltet,
  1074.   * wird der Wert default automatisch an die aufrufende
  1075.   * Prozedur zurückgegeben.
  1076.   */
  1077. int
  1078. Question (WINDOW * wind, char *ask, int def)
  1079. {
  1080.   UBYTE header[MAXSTRLEN];
  1081.  
  1082.   DPOS;
  1083.  
  1084.   if (Flags.saveasking)
  1085.     {
  1086.       sprintf ((char *) header, "%s ask you", NAME);
  1087.  
  1088.       if (Flags.speakmode)
  1089.     Speak (ask);
  1090.  
  1091.       return MyEasyRequest (wind, header, (UBYTE *) "Yes|No", (UBYTE *) "%s",
  1092.                 (UBYTE *) ask);
  1093.     }
  1094.   else
  1095.     return (WORD) def;
  1096. }
  1097.  
  1098.  /*
  1099.   * OpenLibs() öffnet alle notwendigen Libraries, installiert
  1100.   * den Broker und liest verschiedene Listen ein
  1101.   */
  1102. void
  1103. OpenLibs (void)
  1104. {
  1105.   DPOS;
  1106.  
  1107.   IntuitionBase = (INTUITIONBASE *) OpenLibrary ((UBYTE *) "intuition.library", 36);
  1108.   WorkbenchBase = (WORKBENCHBASE *) OpenLibrary ((UBYTE *) "workbench.library", 36);
  1109.   GfxBase = (GFXBASE *) OpenLibrary ((UBYTE *) "graphics.library", 36);
  1110.   GadToolsBase = OpenLibrary ((UBYTE *) "gadtools.library", 36);
  1111.   UtilityBase = OpenLibrary ((UBYTE *) "utility.library", 36);
  1112.   DiskfontBase = OpenLibrary ((UBYTE *) "diskfont.library", 36);
  1113.   CxBase = OpenLibrary ((UBYTE *) "commodities.library", 36);
  1114.   IconBase = OpenLibrary ((UBYTE *) "icon.library", 36);
  1115.  
  1116.   if (!IntuitionBase || !WorkbenchBase || !GfxBase || !GadToolsBase ||
  1117.       !UtilityBase || !DiskfontBase || !CxBase || !IconBase)
  1118.     ErrorHandle ("Version error?", LIBRARY_ERR, OPEN_FAIL, KILL);
  1119.  
  1120.   InstallBroker ();
  1121.  
  1122.   if (Flags.wb_start)
  1123.     BuildAllDataEntries ();
  1124.  
  1125.   BuildValidAddressList ();
  1126.  
  1127.   return;
  1128. }
  1129.  
  1130.  /*
  1131.   * CloseLibs() schließt alle geöffneten Resourcen
  1132.   */
  1133. void
  1134. CloseLibs (void)
  1135. {
  1136.   DPOS;
  1137.  
  1138.   CloseLibrary (IconBase);
  1139.   CloseLibrary (CxBase);
  1140.   CloseLibrary (DiskfontBase);
  1141.   CloseLibrary (UtilityBase);
  1142.   CloseLibrary (GadToolsBase);
  1143.   CloseLibrary ((LIBRARY *) GfxBase);
  1144.   CloseLibrary ((LIBRARY *) WorkbenchBase);
  1145.   CloseLibrary ((LIBRARY *) IntuitionBase);
  1146.   CloseLibrary ((LIBRARY *) DOSBase);
  1147.  
  1148.   return;
  1149. }
  1150.  
  1151.  /*
  1152.   * CloseAll() schließt alle geöffneten und initialisierten
  1153.   * Intuitionobjekte und beendet das Programm
  1154.   */
  1155. void
  1156. CloseAll (void)
  1157. {
  1158.   DPOS;
  1159.  
  1160.   if (Flags.helpmode)
  1161.     Help ();
  1162.   if (Flags.speakmode)
  1163.     RemoveSpeech ();
  1164.   if (appicon)
  1165.     RemoveAppIcon (appicon);
  1166.   if (Flags.dummy1)
  1167.     FreeHardwareData ();
  1168.   if (Flags.dummy2)
  1169.     FreeLibOffData ();
  1170.   if (Flags.dummy3)
  1171.     FreeAmigaGuideContextMemory ();
  1172.   if (Flags.dummy4)
  1173.     FreeValidAddressList ();
  1174.  
  1175.   MyFreeVec (Entries);
  1176.  
  1177.   KillList ();
  1178.  
  1179.   if (SysIdPort)
  1180.     DeletePort (SysIdPort);
  1181.  
  1182.   if (SysWnd)
  1183.     CloseASysWindow (&SysWnd, &SysGList, &SysMenus);
  1184.  
  1185.   CloseDownScreen ();
  1186.  
  1187.   MyFreeVec (Actions);
  1188.  
  1189.   RemoveBroker ();
  1190.  
  1191.   MyFreeVec (RSysName);
  1192.  
  1193.   RemoveTrapHandlers ();
  1194.  
  1195.   CloseLibs ();
  1196.  
  1197.   exit (0);
  1198. }
  1199.